import MarkdownIt from "markdown-it";
import TurndownService from "turndown";

// Markdown转HTML的实例
const md = new MarkdownIt({
  html: true, // 启用 HTML 标签
  breaks: true, // 转换换行符为 <br>
  linkify: true, // 自动识别链接
  typographer: true // 启用智能标点符号替换
});

// HTML转Markdown的实例
const turndownService = new TurndownService({
  headingStyle: "atx", // 使用 # 风格的标题
  hr: "---", // 水平线样式
  bulletListMarker: "-", // 无序列表标记
  codeBlockStyle: "fenced", // 代码块风格
  fence: "```", // 代码块围栏
  emDelimiter: "*", // 斜体分隔符
  strongDelimiter: "**" // 粗体分隔符
});

// 自定义规则：保留一些HTML标签
turndownService.addRule("preserveAttributes", {
  filter: ["span", "div"],
  replacement: (content, node) => {
    const element = node as HTMLElement;
    // 如果有特殊样式，保留为HTML
    if (element.style.cssText || element.className) {
      return element.outerHTML;
    }
    return content;
  }
});

// 自定义规则：处理图片
turndownService.addRule("images", {
  filter: "img",
  replacement: (content, node) => {
    const element = node as HTMLImageElement;
    const alt = element.alt || "";
    const src = element.src || "";
    const title = element.title || "";

    if (title) {
      return `![${alt}](${src} "${title}")`;
    }
    return `![${alt}](${src})`;
  }
});

// 自定义规则：处理链接
turndownService.addRule("links", {
  filter: "a",
  replacement: (content, node) => {
    const element = node as HTMLAnchorElement;
    const href = element.href || "";
    const title = element.title || "";

    if (!href) return content;

    if (title) {
      return `[${content}](${href} "${title}")`;
    }
    return `[${content}](${href})`;
  }
});

// 自定义规则：处理表格
turndownService.addRule("table", {
  filter: "table",
  replacement: (content, node) => {
    const element = node as HTMLTableElement;
    let markdown = "\n";

    const rows = Array.from(element.querySelectorAll("tr"));
    const headerRow = rows[0];
    const bodyRows = rows.slice(1);

    if (headerRow) {
      // 处理表头
      const headerCells = Array.from(headerRow.querySelectorAll("th, td"));
      const headerTexts = headerCells.map(
        cell => cell.textContent?.trim() || ""
      );
      markdown += "| " + headerTexts.join(" | ") + " |\n";

      // 添加分隔行
      const separators = headerCells.map(() => "---");
      markdown += "| " + separators.join(" | ") + " |\n";

      // 处理表格内容
      bodyRows.forEach(row => {
        const cells = Array.from(row.querySelectorAll("td"));
        const cellTexts = cells.map(cell => cell.textContent?.trim() || "");
        markdown += "| " + cellTexts.join(" | ") + " |\n";
      });
    }

    return markdown + "\n";
  }
});

/**
 * 将 Markdown 转换为 HTML
 * @param markdown Markdown 字符串
 * @returns HTML 字符串
 */
export const markdownToHtml = (markdown: string): string => {
  if (!markdown || typeof markdown !== "string") {
    return "";
  }

  try {
    return md.render(markdown);
  } catch (error) {
    console.error("Markdown转HTML失败:", error);
    return markdown; // 转换失败时返回原始内容
  }
};

/**
 * 将 HTML 转换为 Markdown
 * @param html HTML 字符串
 * @returns Markdown 字符串
 */
export const htmlToMarkdown = (html: string): string => {
  if (!html || typeof html !== "string") {
    return "";
  }

  try {
    // 清理HTML，移除不必要的空白和标签
    const cleanHtml = html
      .replace(/\n\s*\n/g, "\n") // 移除多余的空行
      .replace(/^\s+|\s+$/g, ""); // 移除首尾空白

    const markdown = turndownService.turndown(cleanHtml);

    // 后处理：清理多余的空行
    return markdown
      .replace(/\n{3,}/g, "\n\n") // 将3个或更多连续换行替换为2个
      .trim();
  } catch (error) {
    console.error("HTML转Markdown失败:", error);
    return html; // 转换失败时返回原始内容
  }
};

/**
 * 检测内容是否为 HTML 格式
 * @param content 内容字符串
 * @returns 是否为HTML格式
 */
export const isHtmlContent = (content: string): boolean => {
  if (!content || typeof content !== "string") {
    return false;
  }

  // 简单检测是否包含HTML标签
  const htmlTagRegex = /<\/?[a-z][\s\S]*>/i;
  return htmlTagRegex.test(content.trim());
};

/**
 * 检测内容是否为 Markdown 格式
 * @param content 内容字符串
 * @returns 是否为Markdown格式
 */
export const isMarkdownContent = (content: string): boolean => {
  if (!content || typeof content !== "string") {
    return false;
  }

  // 检测常见的Markdown语法
  const markdownPatterns = [
    /^#{1,6}\s+/m, // 标题
    /^\s*[-*+]\s+/m, // 无序列表
    /^\s*\d+\.\s+/m, // 有序列表
    /\*\*[^*]+\*\*/, // 粗体
    /\*[^*]+\*/, // 斜体
    /`[^`]+`/, // 行内代码
    /```[\s\S]*?```/, // 代码块
    /^\s*>/m, // 引用
    /\[([^\]]+)\]\([^)]+\)/, // 链接
    /!\[([^\]]*)\]\([^)]+\)/ // 图片
  ];

  return markdownPatterns.some(pattern => pattern.test(content));
};

/**
 * 智能内容转换
 * 根据目标格式自动选择转换方式
 * @param content 原始内容
 * @param targetFormat 目标格式 'html' | 'markdown'
 * @returns 转换后的内容
 */
export const smartContentConvert = (
  content: string,
  targetFormat: "html" | "markdown"
): string => {
  if (!content) return "";

  const isHtml = isHtmlContent(content);
  const isMarkdown = isMarkdownContent(content);

  if (targetFormat === "html") {
    if (isMarkdown && !isHtml) {
      // 纯Markdown内容，转换为HTML
      return markdownToHtml(content);
    }
    // 已经是HTML或者无法识别格式，直接返回
    return content;
  } else {
    if (isHtml && !isMarkdown) {
      // 纯HTML内容，转换为Markdown
      return htmlToMarkdown(content);
    }
    // 已经是Markdown或者无法识别格式，直接返回
    return content;
  }
};

/**
 * 获取内容的纯文本版本（去除HTML标签和Markdown语法）
 * @param content 内容字符串
 * @returns 纯文本内容
 */
export const getPlainText = (content: string): string => {
  if (!content) return "";

  // 先转换为HTML（如果是Markdown）
  let htmlContent = content;
  if (isMarkdownContent(content) && !isHtmlContent(content)) {
    htmlContent = markdownToHtml(content);
  }

  // 移除HTML标签
  const tempDiv = document.createElement("div");
  tempDiv.innerHTML = htmlContent;
  const plainText = tempDiv.textContent || tempDiv.innerText || "";

  return plainText
    .replace(/\s+/g, " ") // 将多个空白字符替换为单个空格
    .trim();
};

/**
 * 获取内容摘要
 * @param content 内容字符串
 * @param maxLength 最大长度，默认200字符
 * @returns 摘要文本
 */
export const getContentSummary = (
  content: string,
  maxLength: number = 200
): string => {
  const plainText = getPlainText(content);

  if (plainText.length <= maxLength) {
    return plainText;
  }

  // 截取指定长度，并在单词边界处截断
  const truncated = plainText.slice(0, maxLength);
  const lastSpaceIndex = truncated.lastIndexOf(" ");

  if (lastSpaceIndex > maxLength * 0.8) {
    // 如果最后一个空格位置合理
    return truncated.slice(0, lastSpaceIndex) + "...";
  }

  return truncated + "...";
};
